package token

import (
	"context"
	"encoding/json"
	"os"
	"time"

	redis "github.com/redis/go-redis/v9"
	"gopkg.in/yaml.v3"
)

type UserInfo struct {
	UserID string `json:"user_id"`
	Role   string `json:"role"`
}

type TokenCache struct {
	redis *redis.Client
}

func NewTokenCache(configPath string) *TokenCache {
	redis := redis.NewClient(&redis.Options{
		Addr:     configPath,
		Password: "",
		DB:       0,
	})
	return &TokenCache{redis: redis}
}

func (c *TokenCache) Set(token string, userID string, role string) error {
	// 设置token的过期时间
	expiration := time.Hour * 1
	// 设置redis存储结构
	user := UserInfo{
		UserID: userID,
		Role:   role,
	}
	json, err := json.Marshal(user)
	if err != nil {
		return err
	}
	return c.redis.Set(context.Background(), token, json, expiration).Err()
}

func (c *TokenCache) Get(token string) (bool, string, string) {
	userinfo, err := c.redis.Get(context.Background(), token).Result()
	if err != nil {
		return false, "", ""
	}
	var user UserInfo
	err = json.Unmarshal([]byte(userinfo), &user)
	if err != nil {
		return false, "", ""
	}
	return true, user.UserID, user.Role
}

func (c *TokenCache) Delete(token string) error {
	return c.redis.Del(context.Background(), token).Err()
}

func NewRedisClient(configPath string) (*TokenCache, error) {
	yamlFile, err := os.ReadFile(configPath)
	if err != nil {
		return nil, err
	}
	var config Config
	err = yaml.Unmarshal(yamlFile, &config)
	if err != nil {
		return nil, err
	}
	redis := redis.NewClient(&redis.Options{
		Addr:     config.Redis.Addr,
		Password: config.Redis.Password,
		DB:       config.Redis.DB,
	})
	return &TokenCache{redis: redis}, nil
}

type Config struct {
	Redis RedisConfig `yaml:"redis"`
}

type RedisConfig struct {
	Addr     string `yaml:"addr"`
	Password string `yaml:"password"`
	DB       int    `yaml:"db"`
}
